home *** CD-ROM | disk | FTP | other *** search
/ Aminet 44 / Aminet 44 (2001)(GTI - Schatztruhe)[!][Aug 2001].iso / Aminet / comm / mail / YAM23src.lha / Source / YAM_rexx_rxif.c < prev    next >
C/C++ Source or Header  |  2001-05-08  |  64KB  |  2,323 lines
  1. /***************************************************************************
  2.  
  3.  YAM - Yet Another Mailer
  4.  Copyright (C) 1995-2000 by Marcel Beck <mbeck@yam.ch>
  5.  Copyright (C) 2000-2001 by YAM Open Source Team
  6.  
  7.  This program is free software; you can redistribute it and/or modify
  8.  it under the terms of the GNU General Public License as published by
  9.  the Free Software Foundation; either version 2 of the License, or
  10.  (at your option) any later version.
  11.  
  12.  This program is distributed in the hope that it will be useful,
  13.  but WITHOUT ANY WARRANTY; without even the implied warranty of
  14.  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15.  GNU General Public License for more details.
  16.  
  17.  You should have received a copy of the GNU General Public License
  18.  along with this program; if not, write to the Free Software
  19.  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  20.  
  21.  YAM Official Support Site :  http://www.yam.ch
  22.  YAM OpenSource project    :  http://sourceforge.net/projects/yamos/
  23.  
  24.  $Id: YAM_rexx_rxif.c,v 1.9 2001/05/08 22:27:37 damato Exp $
  25.  
  26. ***************************************************************************/
  27. /*
  28.  * Source generated with ARexxBox 1.12 (May 18 1993)
  29.  * And afterwards handmodified to fix bugs!
  30.  * which is Copyright (c) 1992,1993 Michael Balzer
  31.  */
  32.  
  33. #include <exec/types.h>
  34. #include <exec/memory.h>
  35. #include <dos/dos.h>
  36. #include <rexx/storage.h>
  37. #include <rexx/rxslib.h>
  38.  
  39. #ifdef __GNUC__
  40. /* GCC needs all struct defs */
  41. #include <dos/exall.h>
  42. #include <graphics/graphint.h>
  43. #include <intuition/classes.h>
  44. #include <devices/keymap.h>
  45. #include <exec/semaphores.h>
  46. #endif
  47.  
  48. #include <clib/alib_protos.h>
  49. #include <proto/exec.h>
  50. #include <proto/dos.h>
  51. #include <proto/rexxsyslib.h>
  52.  
  53. #include <stdlib.h>
  54. #include <stdio.h>
  55. #include <string.h>
  56. #include <ctype.h>
  57.  
  58. #include "YAM_rexx.h"
  59. #include "YAM.h"
  60.  
  61.  
  62. extern struct ExecBase *SysBase;
  63. extern struct DosLibrary *DOSBase;
  64. extern struct RxsLib *RexxSysBase;
  65.  
  66.  
  67. /* $ARB: I 876664321 */
  68.  
  69. /* $ARB: B 1 SHOW */
  70. /// OK
  71. void rx_show( struct RexxHost *host, struct rxd_show **rxd, long action, struct RexxMsg *rexxmsg )
  72. {
  73.    struct rxd_show *rd = *rxd;
  74.    switch( action )
  75.    {
  76.       case RXIF_INIT:
  77.          *rxd = AllocVec( sizeof *rd, MEMF_CLEAR );
  78.          break;
  79.          
  80.       case RXIF_ACTION:
  81.          set(G->App, MUIA_Application_Iconified, FALSE);
  82.          break;
  83.       
  84.       case RXIF_FREE:
  85.          FreeVec( rd );
  86.          break;
  87.    }
  88.    return;
  89. }
  90. ///
  91. /* $ARB: E 1 SHOW */
  92.  
  93. /* $ARB: B 2 HIDE */
  94. /// OK
  95. void rx_hide( struct RexxHost *host, struct rxd_hide **rxd, long action, struct RexxMsg *rexxmsg )
  96. {
  97.    struct rxd_hide *rd = *rxd;
  98.    switch( action )
  99.    {
  100.       case RXIF_INIT:
  101.          *rxd = AllocVec( sizeof *rd, MEMF_CLEAR );
  102.          break;
  103.          
  104.       case RXIF_ACTION:
  105.          set(G->App, MUIA_Application_Iconified, TRUE);
  106.          break;
  107.       
  108.       case RXIF_FREE:
  109.          FreeVec( rd );
  110.          break;
  111.    }
  112.    return;
  113. }
  114. ///
  115. /* $ARB: E 2 HIDE */
  116.  
  117. /* $ARB: B 3 QUIT */
  118. /// OK
  119. void rx_quit( struct RexxHost *host, struct rxd_quit **rxd, long action, struct RexxMsg *rexxmsg )
  120. {
  121.    struct rxd_quit *rd = *rxd;
  122.    switch( action )
  123.    {
  124.       case RXIF_INIT:
  125.          *rxd = AllocVec( sizeof *rd, MEMF_CLEAR );
  126.          break;
  127.          
  128.       case RXIF_ACTION:
  129.          if (rd->arg.force) set(G->App, MUIA_Application_ForceQuit, TRUE);
  130.          DoMethod(G->App, MUIM_Application_ReturnID, MUIV_Application_ReturnID_Quit);
  131.          break;
  132.       
  133.       case RXIF_FREE:
  134.          FreeVec( rd );
  135.          break;
  136.    }
  137.    return;
  138. }
  139. ///
  140. /* $ARB: E 3 QUIT */
  141.  
  142. /* $ARB: B 4 HELP */
  143. /// OK
  144. void rx_help( struct RexxHost *host, struct rxd_help **rxd, long action, struct RexxMsg *rexxmsg )
  145. {
  146.    struct rxd_help *rd = *rxd;
  147.    struct rxs_command *rxc;
  148.    FILE *fp = NULL, *out = stdout;
  149.    switch( action )
  150.    {
  151.       case RXIF_INIT:
  152.          *rxd = AllocVec( sizeof *rd, MEMF_CLEAR );
  153.          break;
  154.          
  155.       case RXIF_ACTION:
  156.          if (rd->arg.file) if (fp = fopen(rd->arg.file, "w")) out = fp;
  157.          fprintf(out, "Commands for application \"YAM\"\n\nCommand          Template\n-------          --------\n");
  158.          for (rxc = rxs_commandlist; rxc->command; rxc++)
  159.             fprintf(out, "%-16s%c%s%s%s%s%s\n", rxc->command,
  160.                (rxc->results || rxc->args) ? ' ' : '\0', rxc->results ? "VAR/K,STEM/K" : "",
  161.                (rxc->results && rxc->args) ? "," : "", rxc->args ? rxc->args : "",
  162.                rxc->results ? " => " : "", rxc->results ? rxc->results : "");
  163.          if (fp) fclose(fp);
  164.          break;
  165.       
  166.       case RXIF_FREE:
  167.          FreeVec( rd );
  168.          break;
  169.    }
  170.    return;
  171. }
  172. ///
  173. /* $ARB: E 4 HELP */
  174.  
  175. /* $ARB: B 5 INFO */
  176. /// OK
  177. void rx_info( struct RexxHost *host, struct rxd_info **rxd, long action, struct RexxMsg *rexxmsg )
  178. {
  179.    struct rxd_info *rd = *rxd;
  180.    char *key;
  181.    switch( action )
  182.    {
  183.       case RXIF_INIT:
  184.          *rxd = AllocVec( sizeof *rd, MEMF_CLEAR );
  185.          break;
  186.          
  187.       case RXIF_ACTION:
  188.          key = rd->arg.item;
  189.          if (!key) break;
  190.  
  191.          if      (!stricmp(key, "title"))       get(G->App, MUIA_Application_Title, &rd->res.value);
  192.          else if (!stricmp(key, "author"))      get(G->App, MUIA_Application_Author, &rd->res.value);
  193.          else if (!stricmp(key, "copyright"))   get(G->App, MUIA_Application_Copyright, &rd->res.value);
  194.          else if (!stricmp(key, "description")) get(G->App, MUIA_Application_Description, &rd->res.value);
  195.          else if (!stricmp(key, "version"))     get(G->App, MUIA_Application_Version, &rd->res.value);
  196.          else if (!stricmp(key, "base"))        get(G->App, MUIA_Application_Base, &rd->res.value);
  197.          else if (!stricmp(key, "screen"))
  198.          {
  199.             struct Screen *screen;
  200.             struct Node *pubs;
  201.             struct List *pubscreens = LockPubScreenList();
  202.             rd->res.value = "";
  203.             get(G->MA->GUI.WI, MUIA_Window_Screen, &screen);
  204.             for (pubs = pubscreens->lh_Head; pubs->ln_Succ; pubs = pubs->ln_Succ)
  205.                if (((struct PubScreenNode *)pubs)->psn_Screen == screen) rd->res.value = pubs->ln_Name;
  206.             UnlockPubScreenList();
  207.          }
  208.          else rd->rc = RETURN_ERROR;
  209.          break;
  210.       
  211.       case RXIF_FREE:
  212.          FreeVec( rd );
  213.          break;
  214.    }
  215.    return;
  216. }
  217. ///
  218. /* $ARB: E 5 INFO */
  219.  
  220. /* $ARB: B 6 WRITETO */
  221. /// OK
  222. void rx_writeto( struct RexxHost *host, struct rxd_writeto **rxd, long action, struct RexxMsg *rexxmsg )
  223. {
  224.    struct rxd_writeto *rd = *rxd;
  225.    switch( action )
  226.    {
  227.       case RXIF_INIT:
  228.          *rxd = AllocVec( sizeof *rd, MEMF_CLEAR );
  229.          break;
  230.          
  231.       case RXIF_ACTION:
  232.          if (G->WR[G->ActiveWriteWin]) InsertAddresses(G->WR[G->ActiveWriteWin]->GUI.ST_TO, rd->arg.address, rd->arg.add);
  233.          else rd->rc = RETURN_ERROR;
  234.          break;
  235.       
  236.       case RXIF_FREE:
  237.          FreeVec( rd );
  238.          break;
  239.    }
  240.    return;
  241. }
  242. ///
  243. /* $ARB: E 6 WRITETO */
  244.  
  245. /* $ARB: B 7 WRITECC */
  246. /// OK
  247. void rx_writecc( struct RexxHost *host, struct rxd_writecc **rxd, long action, struct RexxMsg *rexxmsg )
  248. {
  249.    struct rxd_writecc *rd = *rxd;
  250.    switch( action )
  251.    {
  252.       case RXIF_INIT:
  253.          *rxd = AllocVec( sizeof *rd, MEMF_CLEAR );
  254.          break;
  255.          
  256.       case RXIF_ACTION:
  257.          if (G->WR[G->ActiveWriteWin]) InsertAddresses(G->WR[G->ActiveWriteWin]->GUI.ST_CC, rd->arg.address, rd->arg.add);
  258.          else rd->rc = RETURN_ERROR;
  259.          break;
  260.       
  261.       case RXIF_FREE:
  262.          FreeVec( rd );
  263.          break;
  264.    }
  265.    return;
  266. }
  267. ///
  268. /* $ARB: E 7 WRITECC */
  269.  
  270. /* $ARB: B 8 WRITEBCC */
  271. /// OK
  272. void rx_writebcc( struct RexxHost *host, struct rxd_writebcc **rxd, long action, struct RexxMsg *rexxmsg )
  273. {
  274.    struct rxd_writebcc *rd = *rxd;
  275.    switch( action )
  276.    {
  277.       case RXIF_INIT:
  278.          *rxd = AllocVec( sizeof *rd, MEMF_CLEAR );
  279.          break;
  280.          
  281.       case RXIF_ACTION:
  282.          if (G->WR[G->ActiveWriteWin]) InsertAddresses(G->WR[G->ActiveWriteWin]->GUI.ST_BCC, rd->arg.address, rd->arg.add);
  283.          else rd->rc = RETURN_ERROR;
  284.          break;
  285.       
  286.       case RXIF_FREE:
  287.          FreeVec( rd );
  288.          break;
  289.    }
  290.    return;
  291. }
  292. ///
  293. /* $ARB: E 8 WRITEBCC */
  294.  
  295. /* $ARB: B 9 WRITEATTACH */
  296. /// OK
  297. void rx_writeattach( struct RexxHost *host, struct rxd_writeattach **rxd, long action, struct RexxMsg *rexxmsg )
  298. {
  299.    struct rxd_writeattach *rd = *rxd;
  300.    switch( action )
  301.    {
  302.       case RXIF_INIT:
  303.          *rxd = AllocVec( sizeof *rd, MEMF_CLEAR );
  304.          break;
  305.          
  306.       case RXIF_ACTION:
  307.          if (access(rd->arg.file,F_OK) == 0 && G->WR[G->ActiveWriteWin])
  308.          {
  309.             WR_AddFileToList(G->ActiveWriteWin, rd->arg.file, NULL, FALSE);
  310.             if (rd->arg.desc)    setstring(G->WR[G->ActiveWriteWin]->GUI.ST_DESC, rd->arg.desc);
  311.             if (rd->arg.encmode) setmutex (G->WR[G->ActiveWriteWin]->GUI.RA_ENCODING, !strnicmp(rd->arg.encmode, "uu", 2) ? 1 : 0);
  312.             if (rd->arg.ctype)   setstring(G->WR[G->ActiveWriteWin]->GUI.ST_CTYPE, rd->arg.ctype);
  313.          }
  314.          else rd->rc = RETURN_ERROR;
  315.          break;
  316.       
  317.       case RXIF_FREE:
  318.          FreeVec( rd );
  319.          break;
  320.    }
  321.    return;
  322. }
  323. ///
  324. /* $ARB: E 9 WRITEATTACH */
  325.  
  326. /* $ARB: B 10 WRITELETTER */
  327. /// OK
  328. void rx_writeletter( struct RexxHost *host, struct rxd_writeletter **rxd, long action, struct RexxMsg *rexxmsg )
  329. {
  330.    struct rxd_writeletter *rd = *rxd;
  331.    switch( action )
  332.    {
  333.       case RXIF_INIT:
  334.          *rxd = AllocVec( sizeof *rd, MEMF_CLEAR );
  335.          break;
  336.          
  337.       case RXIF_ACTION:
  338.          if (G->WR[G->ActiveWriteWin]) if (CopyFile(G->WR_Filename[G->ActiveWriteWin], 0, rd->arg.file, 0))
  339.          {
  340.             if (C->UseSignature && !rd->arg.nosig) WR_AddSignature(G->WR_Filename[G->ActiveWriteWin], -1);
  341.             FileToEditor(G->WR_Filename[G->ActiveWriteWin], G->WR[G->ActiveWriteWin]->GUI.TE_EDIT);
  342.          }
  343.          else rd->rc = RETURN_ERROR;  else rd->rc = RETURN_ERROR;
  344.          break;
  345.  
  346.       case RXIF_FREE:
  347.          FreeVec( rd );
  348.          break;
  349.    }
  350.    return;
  351. }
  352. ///
  353. /* $ARB: E 10 WRITELETTER */
  354.  
  355. /* $ARB: B 11 WRITEOPTIONS */
  356. /// OK
  357. void rx_writeoptions( struct RexxHost *host, struct rxd_writeoptions **rxd, long action, struct RexxMsg *rexxmsg )
  358. {
  359.    struct rxd_writeoptions *rd = *rxd;
  360.    switch( action )
  361.    {
  362.       case RXIF_INIT:
  363.          *rxd = AllocVec( sizeof *rd, MEMF_CLEAR );
  364.          break;
  365.  
  366.       case RXIF_ACTION:
  367.          if (G->WR[G->ActiveWriteWin])
  368.          {
  369.             setcheckmark(G->WR[G->ActiveWriteWin]->GUI.CH_DELSEND, rd->arg.delete);
  370.             setcheckmark(G->WR[G->ActiveWriteWin]->GUI.CH_RECEIPT, rd->arg.receipt);
  371.             setcheckmark(G->WR[G->ActiveWriteWin]->GUI.CH_DISPNOTI, rd->arg.notif);
  372.             setcheckmark(G->WR[G->ActiveWriteWin]->GUI.CH_ADDINFO, rd->arg.addinfo);
  373.             if (rd->arg.importance) setcycle(G->WR[G->ActiveWriteWin]->GUI.CY_IMPORTANCE, *rd->arg.importance);
  374.             if (rd->arg.sig)        setmutex(G->WR[G->ActiveWriteWin]->GUI.RA_SIGNATURE, *rd->arg.sig);
  375.             if (rd->arg.security)   setmutex(G->WR[G->ActiveWriteWin]->GUI.RA_SECURITY, *rd->arg.security);
  376.          }
  377.          else rd->rc = RETURN_ERROR;
  378.          break;
  379.  
  380.       case RXIF_FREE:
  381.          FreeVec( rd );
  382.          break;
  383.    }
  384.    return;
  385. }
  386. ///
  387. /* $ARB: E 11 WRITEOPTIONS */
  388.  
  389. /* $ARB: B 12 WRITEQUEUE */
  390. /// OK
  391. void rx_writequeue( struct RexxHost *host, struct rxd_writequeue **rxd, long action, struct RexxMsg *rexxmsg )
  392. {
  393.    struct rxd_writequeue *rd = *rxd;
  394.    switch( action )
  395.    {
  396.       case RXIF_INIT:
  397.          *rxd = AllocVec( sizeof *rd, MEMF_CLEAR );
  398.          break;
  399.  
  400.       case RXIF_ACTION:
  401.          WR_NewMail(rd->arg.hold ? WRITE_HOLD : WRITE_QUEUE, G->ActiveWriteWin);
  402.          break;
  403.  
  404.       case RXIF_FREE:
  405.          FreeVec( rd );
  406.          break;
  407.    }
  408.    return;
  409. }
  410. ///
  411. /* $ARB: E 12 WRITEQUEUE */
  412.  
  413. /* $ARB: B 13 WRITESEND */
  414. /// OK
  415. void rx_writesend( struct RexxHost *host, struct rxd_writesend **rxd, long action, struct RexxMsg *rexxmsg )
  416. {
  417.    struct rxd_writesend *rd = *rxd;
  418.    switch( action )
  419.    {
  420.       case RXIF_INIT:
  421.          *rxd = AllocVec( sizeof *rd, MEMF_CLEAR );
  422.          break;
  423.  
  424.       case RXIF_ACTION:
  425.          WR_NewMail(WRITE_SEND, G->ActiveWriteWin);
  426.          break;
  427.  
  428.       case RXIF_FREE:
  429.          FreeVec( rd );
  430.          break;
  431.    }
  432.    return;
  433. }
  434. ///
  435. /* $ARB: E 13 WRITESEND */
  436.  
  437. /* $ARB: B 14 MAILWRITE */
  438. /// OK
  439. void rx_mailwrite( struct RexxHost *host, struct rxd_mailwrite **rxd, long action, struct RexxMsg *rexxmsg )
  440. {
  441.    struct rxd_mailwrite *rd = *rxd;
  442.    int winnr;
  443.    switch( action )
  444.    {
  445.       case RXIF_INIT:
  446.          *rxd = AllocVec( sizeof *rd, MEMF_CLEAR );
  447.          break;
  448.  
  449.       case RXIF_ACTION:
  450.          winnr = rd->arg.window ? *rd->arg.window : -1;
  451.          rd->res.window = &G->ActiveWriteWin;
  452.          if (winnr < 0)
  453.          {
  454.             if ((winnr = MA_NewMessage(NEW_NEW, rd->arg.quiet?NEWF_QUIET:0)) >= 0) G->ActiveWriteWin = winnr;
  455.             else rd->rc = RETURN_ERROR;
  456.          }
  457.          else
  458.          {
  459.             if (winnr >= 0 && winnr <= 1) if (G->WR[winnr]) G->ActiveWriteWin = winnr;
  460.             else rd->rc = RETURN_ERROR;
  461.          }
  462.          break;
  463.  
  464.       case RXIF_FREE:
  465.          FreeVec( rd );
  466.          break;
  467.    }
  468.    return;
  469. }
  470. ///
  471. /* $ARB: E 14 MAILWRITE */
  472.  
  473. /* $ARB: B 15 MAILREPLY */
  474. /// OK
  475. void rx_mailreply( struct RexxHost *host, struct rxd_mailreply **rxd, long action, struct RexxMsg *rexxmsg )
  476. {
  477.    struct rxd_mailreply *rd = *rxd;
  478.    int winnr;
  479.    switch( action )
  480.    {
  481.       case RXIF_INIT:
  482.          *rxd = AllocVec( sizeof *rd, MEMF_CLEAR );
  483.          break;
  484.          
  485.       case RXIF_ACTION:
  486.          rd->res.window = &G->ActiveWriteWin;
  487.          if ((winnr = MA_NewMessage(NEW_REPLY, rd->arg.quiet?NEWF_QUIET:0)) >= 0) G->ActiveWriteWin = winnr;
  488.          else rd->rc = RETURN_ERROR;
  489.          break;
  490.       
  491.       case RXIF_FREE:
  492.          FreeVec( rd );
  493.          break;
  494.    }
  495.    return;
  496. }
  497. ///
  498. /* $ARB: E 15 MAILREPLY */
  499.  
  500. /* $ARB: B 16 MAILFORWARD */
  501. /// OK
  502. void rx_mailforward( struct RexxHost *host, struct rxd_mailforward **rxd, long action, struct RexxMsg *rexxmsg )
  503. {
  504.    struct rxd_mailforward *rd = *rxd;
  505.    int winnr;
  506.  
  507.    switch( action )
  508.    {
  509.       case RXIF_INIT:
  510.          *rxd = AllocVec( sizeof *rd, MEMF_CLEAR );
  511.          break;
  512.          
  513.       case RXIF_ACTION:
  514.          rd->res.window = &G->ActiveWriteWin;
  515.          if ((winnr = MA_NewMessage(NEW_FORWARD, rd->arg.quiet?NEWF_QUIET:0)) >= 0) G->ActiveWriteWin = winnr;
  516.          else rd->rc = RETURN_ERROR;
  517.          break;
  518.       
  519.       case RXIF_FREE:
  520.          FreeVec( rd );
  521.          break;
  522.    }
  523.    return;
  524. }
  525. ///
  526. /* $ARB: E 16 MAILFORWARD */
  527.  
  528. /* $ARB: B 17 MAILMOVE */
  529. /// OK
  530. void rx_mailmove( struct RexxHost *host, struct rxd_mailmove **rxd, long action, struct RexxMsg *rexxmsg )
  531. {
  532.    struct rxd_mailmove *rd = *rxd;
  533.    struct Folder *folder;
  534.    switch( action )
  535.    {
  536.       case RXIF_INIT:
  537.          *rxd = AllocVec( sizeof *rd, MEMF_CLEAR );
  538.          break;
  539.          
  540.       case RXIF_ACTION:
  541.          if (folder = FO_GetFolderRexx(rd->arg.folder, NULL))
  542.             MA_MoveCopy(NULL, FO_GetCurrentFolder(), folder, FALSE);
  543.          else rd->rc = RETURN_ERROR;
  544.          break;
  545.       
  546.       case RXIF_FREE:
  547.          FreeVec( rd );
  548.          break;
  549.    }
  550.    return;
  551. }
  552. ///
  553. /* $ARB: E 17 MAILMOVE */
  554.  
  555. /* $ARB: B 18 MAILREAD */
  556. /// OK
  557. void rx_mailread( struct RexxHost *host, struct rxd_mailread **rxd, long action, struct RexxMsg *rexxmsg )
  558. {
  559.    struct rxd_mailread *rd = *rxd;
  560.    struct Mail *mail;
  561.    int winnr;
  562.  
  563.    switch( action )
  564.    {
  565.       case RXIF_INIT:
  566.          *rxd = AllocVec( sizeof *rd, MEMF_CLEAR );
  567.          break;
  568.          
  569.       case RXIF_ACTION:
  570.          winnr = rd->arg.window ? *rd->arg.window : -1;
  571.          rd->res.window = &G->ActiveReadWin;
  572.          if (winnr < 0)
  573.          {
  574.             if (mail = MA_GetActiveMail(ANYBOX, NULL, NULL))
  575.                if ((winnr = RE_Open(-1, TRUE)) >= 0)
  576.                {
  577.                   G->ActiveReadWin = winnr;
  578.                   if (!rd->arg.quiet) set(G->RE[winnr]->GUI.WI, MUIA_Window_Open, TRUE);
  579.                   RE_ReadMessage(winnr, mail);
  580.                }
  581.                else rd->rc = RETURN_ERROR;
  582.             else rd->rc = RETURN_WARN;
  583.          }
  584.          else
  585.          {
  586.             if (winnr >= 0 && winnr <= 3) if (G->RE[winnr]) G->ActiveReadWin = winnr;
  587.             else rd->rc = RETURN_ERROR;
  588.          }
  589.          break;
  590.       
  591.       case RXIF_FREE:
  592.          FreeVec( rd );
  593.          break;
  594.    }
  595.    return;
  596. }
  597. ///
  598. /* $ARB: E 18 MAILREAD */
  599.  
  600. /* $ARB: B 19 MAILSEND */
  601. /// OK
  602. void rx_mailsend( struct RexxHost *host, struct rxd_mailsend **rxd, long action, struct RexxMsg *rexxmsg )
  603. {
  604.    struct rxd_mailsend *rd = *rxd;
  605.    switch( action )
  606.    {
  607.       case RXIF_INIT:
  608.          *rxd = AllocVec( sizeof *rd, MEMF_CLEAR );
  609.          break;
  610.          
  611.       case RXIF_ACTION:
  612.          if (!MA_Send(rd->arg.all ? SEND_ALL : SEND_ACTIVE)) rd->rc = RETURN_WARN;
  613.          break;
  614.       
  615.       case RXIF_FREE:
  616.          FreeVec( rd );
  617.          break;
  618.    }
  619.    return;
  620. }
  621. ///
  622. /* $ARB: E 19 MAILSEND */
  623.  
  624. /* $ARB: B 20 MAILDELETE */
  625. /// OK
  626. void rx_maildelete( struct RexxHost *host, struct rxd_maildelete **rxd, long action, struct RexxMsg *rexxmsg )
  627. {
  628.    struct rxd_maildelete *rd = *rxd;
  629.    switch( action )
  630.    {
  631.       case RXIF_INIT:
  632.          *rxd = AllocVec( sizeof *rd, MEMF_CLEAR );
  633.          break;
  634.          
  635.       case RXIF_ACTION:
  636.          MA_DeleteMessage(rd->arg.atonce, rd->arg.force);
  637.          break;
  638.       
  639.       case RXIF_FREE:
  640.          FreeVec( rd );
  641.          break;
  642.    }
  643.    return;
  644. }
  645. ///
  646. /* $ARB: E 20 MAILDELETE */
  647.  
  648. /* $ARB: B 21 MAILCHECK */
  649. /// OK
  650. void rx_mailcheck( struct RexxHost *host, struct rxd_mailcheck **rxd, long action, struct RexxMsg *rexxmsg )
  651. {
  652.    struct rxd_mailcheck *rd = *rxd;
  653.    int pop, popnr = -2;
  654.    switch( action )
  655.    {
  656.       case RXIF_INIT:
  657.          *rxd = AllocVec( sizeof *rd, MEMF_CLEAR );
  658.          break;
  659.          
  660.       case RXIF_ACTION:
  661.          if (rd->arg.pop) { if ((pop = *rd->arg.pop) >= 0 && pop < MAXP3) if (C->P3[pop]) popnr = pop; }
  662.          else popnr = -1;
  663.          if (popnr > -2)
  664.          {
  665.             if (rd->arg.manual) MA_PopNow(POP_USER, popnr);
  666.             else
  667.             {
  668.                MA_PopNow(POP_REXX, popnr);
  669.                rd->res.downloaded = &G->LastDL.Downloaded;
  670.                rd->res.onserver = &G->LastDL.OnServer;
  671.                rd->res.dupskipped = &G->LastDL.DupSkipped;
  672.                rd->res.deleted = &G->LastDL.Deleted;
  673.                if (G->LastDL.Error) rd->rc = RETURN_WARN;
  674.             }
  675.          }
  676.          else rd->rc = RETURN_ERROR;
  677.          break;
  678.       
  679.       case RXIF_FREE:
  680.          FreeVec( rd );
  681.          break;
  682.    }
  683.    return;
  684. }
  685. ///
  686. /* $ARB: E 21 MAILCHECK */
  687.  
  688. /* $ARB: B 22 MAILIMPORT */
  689. /// OK
  690. void rx_mailimport( struct RexxHost *host, struct rxd_mailimport **rxd, long action, struct RexxMsg *rexxmsg )
  691. {
  692.    struct rxd_mailimport *rd = *rxd;
  693.    switch( action )
  694.    {
  695.       case RXIF_INIT:
  696.          *rxd = AllocVec( sizeof *rd, MEMF_CLEAR );
  697.          break;
  698.          
  699.       case RXIF_ACTION:
  700.          if (!MA_ImportMessages(rd->arg.filename)) rd->rc = RETURN_ERROR;
  701.          else if (!rd->arg.wait) TR_ProcessIMPORTFunc();
  702.          break;
  703.       
  704.       case RXIF_FREE:
  705.          FreeVec( rd );
  706.          break;
  707.    }
  708.    return;
  709. }
  710. ///
  711. /* $ARB: E 22 MAILIMPORT */
  712.  
  713. /* $ARB: B 23 MAILEXPORT */
  714. /// OK
  715. void rx_mailexport( struct RexxHost *host, struct rxd_mailexport **rxd, long action, struct RexxMsg *rexxmsg )
  716. {
  717.    struct rxd_mailexport *rd = *rxd;
  718.    switch( action )
  719.    {
  720.       case RXIF_INIT:
  721.          *rxd = AllocVec( sizeof *rd, MEMF_CLEAR );
  722.          break;
  723.          
  724.       case RXIF_ACTION:
  725.          if (!MA_ExportMessages(rd->arg.all, rd->arg.filename, rd->arg.append)) rd->rc = RETURN_ERROR;
  726.          break;
  727.       
  728.       case RXIF_FREE:
  729.          FreeVec( rd );
  730.          break;
  731.    }
  732.    return;
  733. }
  734. ///
  735. /* $ARB: E 23 MAILEXPORT */
  736.  
  737. /* $ARB: B 24 MAILUPDATE */
  738. /// OK
  739. void rx_mailupdate( struct RexxHost *host, struct rxd_mailupdate **rxd, long action, struct RexxMsg *rexxmsg )
  740. {
  741.    struct rxd_mailupdate *rd = *rxd;
  742.    switch( action )
  743.    {
  744.       case RXIF_INIT:
  745.          *rxd = AllocVec( sizeof *rd, MEMF_CLEAR );
  746.          break;
  747.          
  748.       case RXIF_ACTION:
  749.          DoMethod(G->App, MUIM_CallHook, &MA_RescanIndexHook);
  750.          break;
  751.       
  752.       case RXIF_FREE:
  753.          FreeVec( rd );
  754.          break;
  755.    }
  756.    return;
  757. }
  758. ///
  759. /* $ARB: E 24 MAILUPDATE */
  760.  
  761. /* $ARB: B 25 MAILFILTER */
  762. /// OK
  763. void rx_mailfilter( struct RexxHost *host, struct rxd_mailfilter **rxd, long action, struct RexxMsg *rexxmsg )
  764. {
  765.    struct rxd_mailfilter *rd = *rxd;
  766.    struct RuleResult *rr = &G->RRs;
  767.    switch( action )
  768.    {
  769.       case RXIF_INIT:
  770.          *rxd = AllocVec( sizeof *rd, MEMF_CLEAR );
  771.          break;
  772.          
  773.       case RXIF_ACTION:
  774.          DoMethod(G->App, MUIM_CallHook, &MA_ApplyRulesHook, rd->arg.all ? APPLY_RX_ALL : APPLY_RX, 0, FALSE);
  775.          rd->res.checked = &rr->Checked;
  776.          rd->res.bounced = &rr->Bounced;
  777.          rd->res.forwarded = &rr->Forwarded;
  778.          rd->res.replied = &rr->Replied;
  779.          rd->res.executed = &rr->Executed;
  780.          rd->res.moved = &rr->Moved;
  781.          rd->res.deleted = &rr->Deleted;
  782.          break;
  783.       
  784.       case RXIF_FREE:
  785.          FreeVec( rd );
  786.          break;
  787.    }
  788.    return;
  789. }
  790. ///
  791. /* $ARB: E 25 MAILFILTER */
  792.  
  793. /* $ARB: B 27 MAILINFO */
  794. /// OK
  795. void rx_mailinfo( struct RexxHost *host, struct rxd_mailinfo **rxd, long action, struct RexxMsg *rexxmsg )
  796. {
  797.    struct {
  798.       struct rxd_mailinfo rd;
  799.       long active;
  800.       char from[SIZE_ADDRESS], to[SIZE_ADDRESS], replyto[SIZE_ADDRESS], flags[SIZE_SMALL];
  801.       char filename[SIZE_PATHFILE], date[32];
  802.    } *rd = (void *)*rxd;
  803.    struct Mail *mail;
  804.    struct Folder *folder;
  805.    int pf, vf;
  806.  
  807.    switch( action )
  808.    {
  809.       case RXIF_INIT:
  810.          *rxd = AllocVec( sizeof *rd, MEMF_CLEAR );
  811.          break;
  812.          
  813.       case RXIF_ACTION:
  814.          if (rd->rd.arg.index)
  815.          {
  816.             rd->active = *rd->rd.arg.index;
  817.             DoMethod(G->MA->GUI.NL_MAILS, MUIM_NList_GetEntry, rd->active, &mail);
  818.          }
  819.          else mail = MA_GetActiveMail(ANYBOX, &folder, (int *)&rd->active);
  820.          if (mail)
  821.          {
  822.             pf = (mail->Flags & 0x0700) >> 8;
  823.             vf = (mail->Flags & 0x3800) >> 11;
  824.             GetMailFile(rd->rd.res.filename = rd->filename, folder, mail);
  825.             rd->rd.res.index = &rd->active;
  826.             rd->rd.res.status = Status[mail->Status];
  827.             stccpy(rd->rd.res.from    = rd->from   , BuildAddrName2(&mail->From), SIZE_ADDRESS);
  828.             stccpy(rd->rd.res.to      = rd->to     , BuildAddrName2(&mail->To), SIZE_ADDRESS);
  829.             stccpy(rd->rd.res.replyto = rd->replyto, BuildAddrName2(GetReturnAddress(mail)), SIZE_ADDRESS);
  830.             strcpy(rd->rd.res.date    = rd->date   , DateStamp2String(&mail->Date, DSS_USDATETIME));
  831.             rd->rd.res.subject = mail->Subject;
  832.             rd->rd.res.size = &mail->Size;
  833.             rd->rd.res.msgid = &mail->cMsgID;
  834.             sprintf(rd->rd.res.flags = rd->flags, "%c%c%c%c%c-%c%c",
  835.                (mail->Flags&MFLAG_MULTIRCPT)?'M':'-', (mail->Flags&MFLAG_MULTIPART)?'A':'-', (mail->Flags&MFLAG_REPORT)?'R':'-',
  836.                (mail->Flags&MFLAG_CRYPT)?'C':'-', (mail->Flags&MFLAG_SIGNED)?'S':'-', pf?pf+'0':'-', vf?vf+'0':'-');
  837.          }
  838.          else rd->rd.rc = RETURN_ERROR;
  839.          break;
  840.       
  841.       case RXIF_FREE:
  842.          FreeVec( rd );
  843.          break;
  844.    }
  845.    return;
  846. }
  847. ///
  848. /* $ARB: E 27 MAILINFO */
  849.  
  850. /* $ARB: B 28 SETFOLDER */
  851. /// OK
  852. void rx_setfolder( struct RexxHost *host, struct rxd_setfolder **rxd, long action, struct RexxMsg *rexxmsg )
  853. {
  854.    struct rxd_setfolder *rd = *rxd;
  855.    struct Folder *folder;
  856.    switch( action )
  857.    {
  858.       case RXIF_INIT:
  859.          *rxd = AllocVec( sizeof *rd, MEMF_CLEAR );
  860.          break;
  861.          
  862.       case RXIF_ACTION:
  863.          if (folder = FO_GetFolderRexx(rd->arg.folder, NULL)) MA_ChangeFolder(folder);
  864.          else rd->rc = RETURN_ERROR;
  865.          break;
  866.       
  867.       case RXIF_FREE:
  868.          FreeVec( rd );
  869.          break;
  870.    }
  871.    return;
  872. }
  873. ///
  874. /* $ARB: E 28 SETFOLDER */
  875.  
  876. /* $ARB: B 29 SETMAIL */
  877. /// OK
  878. void rx_setmail( struct RexxHost *host, struct rxd_setmail **rxd, long action, struct RexxMsg *rexxmsg )
  879. {
  880.    struct rxd_setmail *rd = *rxd;
  881.    int mail, max;
  882.    switch( action )
  883.    {
  884.       case RXIF_INIT:
  885.          *rxd = AllocVec( sizeof *rd, MEMF_CLEAR );
  886.          break;
  887.          
  888.       case RXIF_ACTION:
  889.          mail = *rd->arg.num;
  890.          get(G->MA->GUI.NL_MAILS, MUIA_NList_Entries, &max);
  891.          if (mail < 0 || mail >= max) rd->rc = RETURN_ERROR;
  892.          else set(G->MA->GUI.NL_MAILS, MUIA_NList_Active, mail);
  893.          break;
  894.       
  895.       case RXIF_FREE:
  896.          FreeVec( rd );
  897.          break;
  898.    }
  899.    return;
  900. }
  901. ///
  902. /* $ARB: E 29 SETMAIL */
  903.  
  904. /* $ARB: B 30 WRITEEDITOR */
  905. /// OK
  906. void rx_writeeditor( struct RexxHost *host, struct rxd_writeeditor **rxd, long action, struct RexxMsg *rexxmsg )
  907. {
  908.    struct rxd_writeeditor *rd = *rxd;
  909.    switch( action )
  910.    {
  911.       case RXIF_INIT:
  912.          *rxd = AllocVec( sizeof *rd, MEMF_CLEAR );
  913.          break;
  914.          
  915.       case RXIF_ACTION:
  916.          if (G->WR[G->ActiveWriteWin])
  917.          {
  918.             ULONG p = DoMethod(G->WR[G->ActiveWriteWin]->GUI.TE_EDIT, MUIM_TextEditor_ARexxCmd, rd->arg.command);
  919.             switch (p)
  920.             {
  921.                case FALSE: rd->rc = RETURN_WARN; break;
  922.                case TRUE:  break;
  923.                default:    rd->res.result = (char *)p; break;
  924.             }
  925.          }
  926.          else rd->rc = RETURN_ERROR;
  927.          break;
  928.       
  929.       case RXIF_FREE:
  930.          if (rd->res.result) FreeVec(rd->res.result);
  931.          FreeVec( rd );
  932.          break;
  933.    }
  934.    return;
  935. }
  936. ///
  937. /* $ARB: E 30 WRITEEDITOR */
  938.  
  939. /* $ARB: B 31 REQUEST */
  940. /// OK
  941. void rx_request( struct RexxHost *host, struct rxd_request **rxd, long action, struct RexxMsg *rexxmsg )
  942. {
  943.    struct {
  944.       struct rxd_request rd;
  945.       long result;
  946.    } *rd = (void *)*rxd;
  947.    char *reqtext;
  948.  
  949.    switch( action )
  950.    {
  951.       case RXIF_INIT:
  952.          *rxd = AllocVec( sizeof *rd, MEMF_CLEAR );
  953.          break;
  954.          
  955.       case RXIF_ACTION:
  956.          reqtext = AllocReqText(rd->rd.arg.body);
  957.          rd->result = MUI_Request(G->App, NULL, 0, NULL, rd->rd.arg.gadgets, reqtext);
  958.          rd->rd.res.result = &rd->result;
  959.          free(reqtext);
  960.          break;
  961.       
  962.       case RXIF_FREE:
  963.          FreeVec( rd );
  964.          break;
  965.    }
  966.    return;
  967. }
  968. ///
  969. /* $ARB: E 31 REQUEST */
  970.  
  971. /* $ARB: B 32 MAILARCHIVE */
  972. /// OK OBSOLETE
  973. void rx_mailarchive( struct RexxHost *host, struct rxd_mailarchive **rxd, long action, struct RexxMsg *rexxmsg )
  974. {
  975.    rx_mailmove(host, (struct rxd_mailmove **)rxd, action, rexxmsg);
  976. }
  977. ///
  978. /* $ARB: E 32 MAILARCHIVE */
  979.  
  980. /* $ARB: B 33 MAILSENDALL */
  981. /// OK OBSOLETE
  982. void rx_mailsendall( struct RexxHost *host, struct rxd_mailsendall **rxd, long action, struct RexxMsg *rexxmsg )
  983. {
  984.    struct rxd_mailsendall *rd = *rxd;
  985.    switch( action )
  986.    {
  987.       case RXIF_INIT:
  988.          *rxd = AllocVec( sizeof *rd, MEMF_CLEAR );
  989.          break;
  990.          
  991.       case RXIF_ACTION:
  992.          if (!MA_Send(SEND_ALL)) rd->rc = RETURN_WARN;
  993.          break;
  994.       
  995.       case RXIF_FREE:
  996.          FreeVec( rd );
  997.          break;
  998.    }
  999.    return;
  1000. }
  1001. ///
  1002. /* $ARB: E 33 MAILSENDALL */
  1003.  
  1004. /* $ARB: B 35 GETFOLDERINFO */
  1005. /// OK
  1006. void rx_getfolderinfo( struct RexxHost *host, struct rxd_getfolderinfo **rxd, long action, struct RexxMsg *rexxmsg )
  1007. {
  1008.    struct {
  1009.       struct rxd_getfolderinfo rd;
  1010.       char result[SIZE_SMALL];
  1011.    } *rd = (void *)*rxd;
  1012.    struct Folder *fo;
  1013.    int num;
  1014.    char *key;
  1015.  
  1016.    switch( action )
  1017.    {
  1018.       case RXIF_INIT:
  1019.          *rxd = AllocVec( sizeof *rd, MEMF_CLEAR );
  1020.          break;
  1021.          
  1022.       case RXIF_ACTION:
  1023.          key = rd->rd.arg.item;
  1024.          fo = FO_GetCurrentFolder();
  1025.          get(G->MA->GUI.NL_FOLDERS, MUIA_NList_Active, &num);
  1026.          if (!strnicmp(key, "NUM", 3)) sprintf(rd->rd.res.value = rd->result, "%ld", num);
  1027.          else if (!strnicmp(key, "NAM", 3)) rd->rd.res.value = fo->Name;
  1028.          else if (!strnicmp(key, "PAT", 3)) rd->rd.res.value = fo->Path;
  1029.          else if (!strnicmp(key, "MAX", 3)) sprintf(rd->rd.res.value = rd->result, "%ld", fo->Total);
  1030.          else rd->rd.rc = RETURN_ERROR;
  1031.          break;
  1032.       
  1033.       case RXIF_FREE:
  1034.          FreeVec( rd );
  1035.          break;
  1036.    }
  1037.    return;
  1038. }
  1039. ///
  1040. /* $ARB: E 35 GETFOLDERINFO */
  1041.  
  1042. /* $ARB: B 36 GETMAILINFO */
  1043. /// OK OBSOLETE
  1044. void rx_getmailinfo( struct RexxHost *host, struct rxd_getmailinfo **rxd, long action, struct RexxMsg *rexxmsg )
  1045. {
  1046.    struct {
  1047.       struct rxd_getmailinfo rd;
  1048.       char result[SIZE_LARGE];
  1049.    } *rd = (void *)*rxd;
  1050.    struct Mail *mail;
  1051.    int active;
  1052.    char *key;
  1053.  
  1054.    switch( action )
  1055.    {
  1056.       case RXIF_INIT:
  1057.          *rxd = AllocVec( sizeof *rd, MEMF_CLEAR );
  1058.          break;
  1059.          
  1060.       case RXIF_ACTION:
  1061.          if (mail = MA_GetActiveMail(ANYBOX, NULL, &active))
  1062.          {
  1063.             rd->rd.res.value = rd->result;
  1064.             key = rd->rd.arg.item;
  1065.             if (!strnicmp(key, "ACT", 3)) sprintf(rd->result, "%d", active);
  1066.             else if (!strnicmp(key, "STA", 3)) rd->rd.res.value = Status[mail->Status];
  1067.             else if (!strnicmp(key, "FRO", 3)) strcpy(rd->result, BuildAddrName2(&mail->From));
  1068.             else if (!strnicmp(key, "TO" , 2)) strcpy(rd->result, BuildAddrName2(&mail->To));
  1069.             else if (!strnicmp(key, "REP", 3)) strcpy(rd->result, BuildAddrName2(GetReturnAddress(mail)));
  1070.             else if (!strnicmp(key, "SUB", 3)) rd->rd.res.value = mail->Subject;
  1071.             else if (!strnicmp(key, "FIL", 3)) GetMailFile(rd->rd.res.value = rd->result, mail->Folder, mail);
  1072.             else rd->rd.rc = RETURN_ERROR;
  1073.          }
  1074.          else rd->rd.rc = RETURN_ERROR;
  1075.          break;
  1076.       
  1077.       case RXIF_FREE:
  1078.          FreeVec( rd );
  1079.          break;
  1080.    }
  1081.    return;
  1082. }
  1083. ///
  1084. /* $ARB: E 36 GETMAILINFO */
  1085.  
  1086. /* $ARB: B 37 GETCONFIGINFO */
  1087. /// OK OBSOLETE
  1088. void rx_getconfiginfo( struct RexxHost *host, struct rxd_getconfiginfo **rxd, long action, struct RexxMsg *rexxmsg )
  1089. {
  1090.    struct rxd_getconfiginfo *rd = *rxd;
  1091.    char *key;
  1092.    switch( action )
  1093.    {
  1094.       case RXIF_INIT:
  1095.          *rxd = AllocVec( sizeof *rd, MEMF_CLEAR );
  1096.          break;
  1097.          
  1098.       case RXIF_ACTION:
  1099.          key = rd->arg.item;
  1100.          if (!strnicmp(key, "NAM", 3)) rd->res.value = C->RealName;
  1101.          else if (!strnicmp(key, "EMA", 3)) rd->res.value = C->EmailAddress;
  1102.          else rd->rc = RETURN_ERROR;
  1103.          break;
  1104.       
  1105.       case RXIF_FREE:
  1106.          FreeVec( rd );
  1107.          break;
  1108.    }
  1109.    return;
  1110. }
  1111. ///
  1112. /* $ARB: E 37 GETCONFIGINFO */
  1113.  
  1114. /* $ARB: B 38 FOLDERINFO */
  1115. /// OK
  1116. void rx_folderinfo( struct RexxHost *host, struct rxd_folderinfo **rxd, long action, struct RexxMsg *rexxmsg )
  1117. {
  1118.    struct rxd_folderinfo *rd = *rxd;
  1119.    struct Folder *fo;
  1120.    static long num;
  1121.    switch( action )
  1122.    {
  1123.       case RXIF_INIT:
  1124.          *rxd = AllocVec( sizeof *rd, MEMF_CLEAR );
  1125.          break;
  1126.          
  1127.       case RXIF_ACTION:
  1128.          fo = rd->arg.folder ? FO_GetFolderRexx(rd->arg.folder, NULL) : FO_GetCurrentFolder();
  1129.          if (fo)
  1130.          {
  1131.             num = FO_GetFolderPosition(fo);
  1132.             rd->res.number = #
  1133.             rd->res.name = fo->Name;
  1134.             rd->res.path = fo->Path;
  1135.             rd->res.total = (long *)&fo->Total;
  1136.             rd->res.new = (long *)&fo->New;
  1137.             rd->res.unread = (long *)&fo->Unread;
  1138.             rd->res.size = (long *)&fo->Size;
  1139.             rd->res.type = (long *)&fo->Type;
  1140.          }
  1141.          else rd->rc = RETURN_ERROR;
  1142.          break;
  1143.       
  1144.       case RXIF_FREE:
  1145.          FreeVec( rd );
  1146.          break;
  1147.    }
  1148.    return;
  1149. }
  1150. ///
  1151. /* $ARB: E 38 FOLDERINFO */
  1152.  
  1153. /* $ARB: B 40 WRITESUBJECT */
  1154. /// OK
  1155. void rx_writesubject( struct RexxHost *host, struct rxd_writesubject **rxd, long action, struct RexxMsg *rexxmsg )
  1156. {
  1157.    struct rxd_writesubject *rd = *rxd;
  1158.    switch( action )
  1159.    {
  1160.       case RXIF_INIT:
  1161.          *rxd = AllocVec( sizeof *rd, MEMF_CLEAR );
  1162.          break;
  1163.          
  1164.       case RXIF_ACTION:
  1165.          if (G->WR[G->ActiveWriteWin]) setstring(G->WR[G->ActiveWriteWin]->GUI.ST_SUBJECT, rd->arg.subject);
  1166.          break;
  1167.       
  1168.       case RXIF_FREE:
  1169.          FreeVec( rd );
  1170.          break;
  1171.    }
  1172.    return;
  1173. }
  1174. ///
  1175. /* $ARB: E 40 WRITESUBJECT */
  1176.  
  1177. /* $ARB: B 41 SCREENTOBACK */
  1178. /// OK
  1179. void rx_screentoback( struct RexxHost *host, struct rxd_screentoback **rxd, long action, struct RexxMsg *rexxmsg )
  1180. {
  1181.    struct rxd_screentoback *rd = *rxd;
  1182.    switch( action )
  1183.    {
  1184.       case RXIF_INIT:
  1185.          *rxd = AllocVec( sizeof *rd, MEMF_CLEAR );
  1186.          break;
  1187.          
  1188.       case RXIF_ACTION:
  1189.          rd->rc = 0;
  1190.          if (G->MA) DoMethod(G->MA->GUI.WI, MUIM_Window_ScreenToBack);
  1191.          else rd->rc = RETURN_WARN;
  1192.          break;
  1193.       
  1194.       case RXIF_FREE:
  1195.          FreeVec( rd );
  1196.          break;
  1197.    }
  1198.    return;
  1199. }
  1200. ///
  1201. /* $ARB: E 41 SCREENTOBACK */
  1202.  
  1203. /* $ARB: B 42 SCREENTOFRONT */
  1204. /// OK
  1205. void rx_screentofront( struct RexxHost *host, struct rxd_screentofront **rxd, long action, struct RexxMsg *rexxmsg )
  1206. {
  1207.    struct rxd_screentofront *rd = *rxd;
  1208.    switch( action )
  1209.    {
  1210.       case RXIF_INIT:
  1211.          *rxd = AllocVec( sizeof *rd, MEMF_CLEAR );
  1212.          break;
  1213.          
  1214.       case RXIF_ACTION:
  1215.          rd->rc = 0;
  1216.          if (G->MA) DoMethod(G->MA->GUI.WI, MUIM_Window_ScreenToFront);
  1217.          else rd->rc = RETURN_WARN;
  1218.          break;
  1219.       
  1220.       case RXIF_FREE:
  1221.          FreeVec( rd );
  1222.          break;
  1223.    }
  1224.    return;
  1225. }
  1226. ///
  1227. /* $ARB: E 42 SCREENTOFRONT */
  1228.  
  1229. /* $ARB: B 46 SETFLAG */
  1230. /// OK
  1231. void rx_setflag( struct RexxHost *host, struct rxd_setflag **rxd, long action, struct RexxMsg *rexxmsg )
  1232. {
  1233.    struct rxd_setflag *rd = *rxd;
  1234.    int flag;
  1235.    struct Mail *mail;
  1236.    switch( action )
  1237.    {
  1238.       case RXIF_INIT:
  1239.          *rxd = AllocVec( sizeof *rd, MEMF_CLEAR );
  1240.          break;
  1241.          
  1242.       case RXIF_ACTION:
  1243.          if (mail = MA_GetActiveMail(ANYBOX, NULL, NULL))
  1244.          {
  1245.             if (rd->arg.vol) { if ((flag = *rd->arg.vol) >= 0 && flag < 8)
  1246.                mail->Flags = (mail->Flags&0xC7FF) | (flag<<11);
  1247.                
  1248.             else rd->rc = RETURN_ERROR;
  1249.             }
  1250.             if (rd->arg.per) if ((flag = *rd->arg.per) >= 0 && flag < 8)
  1251.             {
  1252.                if (flag != ((mail->Flags&0x0700)>>8))
  1253.                {
  1254.                   mail->Flags = (mail->Flags&0xF8FF) | (flag<<8);
  1255.                   MA_SetMailStatus(mail, mail->Status|0x100);
  1256.                }
  1257.             }
  1258.             else rd->rc = RETURN_ERROR;
  1259.          }
  1260.          else rd->rc = RETURN_WARN;
  1261.          break;
  1262.       
  1263.       case RXIF_FREE:
  1264.          FreeVec( rd );
  1265.          break;
  1266.    }
  1267.    return;
  1268. }
  1269. ///
  1270. /* $ARB: E 46 SETFLAG */
  1271.  
  1272. /* $ARB: B 47 MAILEDIT */
  1273. /// OK
  1274. void rx_mailedit( struct RexxHost *host, struct rxd_mailedit **rxd, long action, struct RexxMsg *rexxmsg )
  1275. {
  1276.    struct rxd_mailedit *rd = *rxd;
  1277.    int winnr;
  1278.    switch( action )
  1279.    {
  1280.       case RXIF_INIT:
  1281.          *rxd = AllocVec( sizeof *rd, MEMF_CLEAR );
  1282.          break;
  1283.          
  1284.       case RXIF_ACTION:
  1285.          rd->res.window = &G->ActiveWriteWin;
  1286.          if ((winnr = MA_NewMessage(NEW_EDIT, rd->arg.quiet?NEWF_QUIET:0)) >= 0) G->ActiveWriteWin = winnr;
  1287.          else rd->rc = RETURN_ERROR;
  1288.          break;
  1289.       
  1290.       case RXIF_FREE:
  1291.          FreeVec( rd );
  1292.          break;
  1293.    }
  1294.    return;
  1295. }
  1296. ///
  1297. /* $ARB: E 47 MAILEDIT */
  1298.  
  1299. /* $ARB: B 48 READINFO */
  1300. /// OK
  1301. void rx_readinfo( struct RexxHost *host, struct rxd_readinfo **rxd, long action, struct RexxMsg *rexxmsg )
  1302. {
  1303.    struct rxd_readinfo *rd = *rxd;
  1304.    struct Part *part;
  1305.    int i, parts;
  1306.    switch( action )
  1307.    {
  1308.       case RXIF_INIT:
  1309.          *rxd = AllocVec( sizeof *rd, MEMF_CLEAR );
  1310.          break;
  1311.          
  1312.       case RXIF_ACTION:
  1313.          if (G->RE[G->ActiveReadWin])
  1314.          {
  1315.             for (parts = 0, part = G->RE[G->ActiveReadWin]->FirstPart->Next; part; parts++, part = part->Next);
  1316.             rd->res.filename = calloc(parts+1, sizeof(char *));
  1317.             rd->res.filetype = calloc(parts+1, sizeof(char *));
  1318.             rd->res.filesize = calloc(parts+1, sizeof(long));
  1319.             rd->res.tempfile = calloc(parts+1, sizeof(char *));
  1320.             for (i = 0, part = G->RE[G->ActiveReadWin]->FirstPart->Next; part; i++, part = part->Next)
  1321.             {
  1322.                rd->res.filename[i] = part->Name;
  1323.                rd->res.filetype[i] = part->ContentType;
  1324.                rd->res.filesize[i] = (long *)&part->Size;
  1325.                rd->res.tempfile[i] = part->Filename;
  1326.             }
  1327.          }
  1328.          else rd->rc = RETURN_ERROR;
  1329.          break;
  1330.       
  1331.       case RXIF_FREE:
  1332.          if (rd->res.filename) free(rd->res.filename);
  1333.          if (rd->res.filetype) free(rd->res.filetype);
  1334.          if (rd->res.filesize) free(rd->res.filesize);
  1335.          if (rd->res.tempfile) free(rd->res.tempfile);
  1336.          FreeVec( rd );
  1337.          break;
  1338.    }
  1339.    return;
  1340. }
  1341. ///
  1342. /* $ARB: E 48 READINFO */
  1343.  
  1344. /* $ARB: B 49 READSAVE */
  1345. /// OK
  1346. void rx_readsave( struct RexxHost *host, struct rxd_readsave **rxd, long action, struct RexxMsg *rexxmsg )
  1347. {
  1348.    struct rxd_readsave *rd = *rxd;
  1349.    struct Part *part;
  1350.    struct TempFile *tf;
  1351.    BOOL success = FALSE;
  1352.    char file[SIZE_PATHFILE];
  1353.    switch( action )
  1354.    {
  1355.       case RXIF_INIT:
  1356.          *rxd = AllocVec( sizeof *rd, MEMF_CLEAR );
  1357.          break;
  1358.          
  1359.       case RXIF_ACTION:
  1360.          if (G->RE[G->ActiveReadWin])
  1361.             if (rd->arg.part)
  1362.             {
  1363.                for (part = G->RE[G->ActiveReadWin]->FirstPart->Next; part; part = part->Next)
  1364.                   if (part->Nr == *(rd->arg.part))
  1365.                      if (RE_DecodePart(part))
  1366.                      {
  1367.                         strmfp(file, C->DetachDir, part->Name);
  1368.                         success = RE_Export(G->ActiveReadWin, part->Filename, rd->arg.filename ? rd->arg.filename : "", part->Name, part->Nr, TRUE, rd->arg.overwrite, part->ContentType);
  1369.                      }
  1370.             }
  1371.             else if (tf = OpenTempFile("w"))
  1372.             {
  1373.                RE_SaveDisplay(G->ActiveReadWin, tf->FP);
  1374.                fclose(tf->FP); tf->FP = NULL;
  1375.                success = RE_Export(G->ActiveReadWin, tf->Filename, rd->arg.filename ? rd->arg.filename : "", "", 0, TRUE, rd->arg.overwrite, ContType[CT_TX_PLAIN]);
  1376.                CloseTempFile(tf);
  1377.             }
  1378.          if (!success) rd->rc = RETURN_ERROR;
  1379.          break;
  1380.       
  1381.       case RXIF_FREE:
  1382.          FreeVec( rd );
  1383.          break;
  1384.    }
  1385.    return;
  1386. }
  1387. ///
  1388. /* $ARB: E 49 READSAVE */
  1389.  
  1390. /* $ARB: B 50 READPRINT */
  1391. /// OK
  1392. void rx_readprint( struct RexxHost *host, struct rxd_readprint **rxd, long action, struct RexxMsg *rexxmsg )
  1393. {
  1394.    struct rxd_readprint *rd = *rxd;
  1395.    struct Part *part;
  1396.    FILE *prt;
  1397.    BOOL success = FALSE;
  1398.    switch( action )
  1399.    {
  1400.       case RXIF_INIT:
  1401.          *rxd = AllocVec( sizeof *rd, MEMF_CLEAR );
  1402.          break;
  1403.          
  1404.       case RXIF_ACTION:
  1405.          if (C->PrinterCheck) if (!CheckPrinter()) { rd->rc = RETURN_ERROR; break; }
  1406.          if (G->RE[G->ActiveReadWin])
  1407.             if (rd->arg.part)
  1408.             {
  1409.                for (part = G->RE[G->ActiveReadWin]->FirstPart->Next; part; part = part->Next)
  1410.                   if (part->Nr == *(rd->arg.part))
  1411.                      if (RE_DecodePart(part)) success = CopyFile("PRT:", 0, part->Filename, 0);
  1412.             }
  1413.             else if (prt = fopen("PRT:","w"))
  1414.             {
  1415.                RE_SaveDisplay(G->ActiveReadWin, prt);
  1416.                fclose(prt);
  1417.                success = TRUE;
  1418.             }
  1419.          if (!success) rd->rc = RETURN_ERROR;
  1420.          break;
  1421.       
  1422.       case RXIF_FREE:
  1423.          FreeVec( rd );
  1424.          break;
  1425.    }
  1426.    return;
  1427. }
  1428. ///
  1429. /* $ARB: E 50 READPRINT */
  1430.  
  1431. /* $ARB: B 51 MAILBOUNCE */
  1432. /// OK
  1433. void rx_mailbounce( struct RexxHost *host, struct rxd_mailbounce **rxd, long action, struct RexxMsg *rexxmsg )
  1434. {
  1435.    struct rxd_mailbounce *rd = *rxd;
  1436.    int winnr;
  1437.    switch( action )
  1438.    {
  1439.       case RXIF_INIT:
  1440.          *rxd = AllocVec( sizeof *rd, MEMF_CLEAR );
  1441.          break;
  1442.          
  1443.       case RXIF_ACTION:
  1444.          rd->res.window = &G->ActiveWriteWin;
  1445.          if ((winnr = MA_NewMessage(NEW_BOUNCE, rd->arg.quiet?NEWF_QUIET:0)) >= 0) G->ActiveWriteWin = winnr;
  1446.          else rd->rc = RETURN_ERROR;
  1447.          break;
  1448.       
  1449.       case RXIF_FREE:
  1450.          FreeVec( rd );
  1451.          break;
  1452.    }
  1453.    return;
  1454. }
  1455. ///
  1456. /* $ARB: E 51 MAILBOUNCE */
  1457.  
  1458. /* $ARB: B 52 ADDRFIND */
  1459. /// OK
  1460. void rx_addrfind( struct RexxHost *host, struct rxd_addrfind **rxd, long action, struct RexxMsg *rexxmsg )
  1461. {
  1462.    struct rxd_addrfind *rd = *rxd;
  1463.    int mode;
  1464.    switch( action )
  1465.    {
  1466.       case RXIF_INIT:
  1467.          *rxd = AllocVec( sizeof *rd, MEMF_CLEAR );
  1468.          break;
  1469.          
  1470.       case RXIF_ACTION:
  1471.          G->AB->Hits = 0;
  1472.          if (rd->arg.nameonly) mode = rd->arg.emailonly ? ABF_RX_NAMEEMAIL : ABF_RX_NAME;
  1473.                           else mode = rd->arg.emailonly ? ABF_RX_EMAIL     : ABF_RX;
  1474.          AB_FindEntry(MUIV_NListtree_GetEntry_ListNode_Root, rd->arg.pattern, mode, NULL);
  1475.          if (G->AB->Hits)
  1476.          {
  1477.             rd->res.alias = calloc(G->AB->Hits+1, sizeof(char *));
  1478.             AB_FindEntry(MUIV_NListtree_GetEntry_ListNode_Root, rd->arg.pattern, mode, rd->res.alias);
  1479.          }
  1480.          else rd->rc = RETURN_WARN;
  1481.          break;
  1482.       
  1483.       case RXIF_FREE:
  1484.          if (rd->res.alias) free(rd->res.alias);
  1485.          FreeVec( rd );
  1486.          break;
  1487.    }
  1488.    return;
  1489. }
  1490. ///
  1491. /* $ARB: E 52 ADDRFIND */
  1492.  
  1493. /* $ARB: B 53 ADDRINFO */
  1494. /// OK
  1495. void rx_addrinfo( struct RexxHost *host, struct rxd_addrinfo **rxd, long action, struct RexxMsg *rexxmsg )
  1496. {
  1497.    struct {
  1498.       struct rxd_addrinfo rd;
  1499.       char *members, **memberptr;
  1500.    } *rd = (void *)*rxd;
  1501.    static char *types[3] = { "P","L","G"};
  1502.    char *ptr;
  1503.    struct MUI_NListtree_TreeNode *tn;
  1504.    int i, hits;
  1505.    switch( action )
  1506.    {
  1507.       case RXIF_INIT:
  1508.          *rxd = AllocVec( sizeof *rd, MEMF_CLEAR );
  1509.          break;
  1510.          
  1511.       case RXIF_ACTION:
  1512.          hits = 0;
  1513.          if (AB_SearchEntry(MUIV_NListtree_GetEntry_ListNode_Root, rd->rd.arg.alias, ASM_ALIAS|ASM_USER|ASM_LIST|ASM_GROUP, &hits, &tn))
  1514.          {
  1515.             struct ABEntry *ab = (struct ABEntry *)tn->tn_User;
  1516.             rd->rd.res.type = types[ab->Type];
  1517.             rd->rd.res.name = ab->RealName;
  1518.             rd->rd.res.email = ab->Address;
  1519.             rd->rd.res.pgp = ab->PGPId;
  1520.             rd->rd.res.homepage = ab->Homepage;
  1521.             rd->rd.res.street = ab->Street;
  1522.             rd->rd.res.city = ab->City;
  1523.             rd->rd.res.country = ab->Country;
  1524.             rd->rd.res.phone = ab->Phone;
  1525.             rd->rd.res.comment = ab->Comment;
  1526.             rd->rd.res.birthdate = &ab->BirthDay;
  1527.             rd->rd.res.image = ab->Photo;
  1528.             if (ab->Members)
  1529.             {
  1530.                rd->members = calloc(strlen(ab->Members)+1,1);
  1531.                strcpy(rd->members, ab->Members);
  1532.                for (hits = 0, ptr = rd->members; *ptr; hits++, ptr++)
  1533.                {
  1534.                   if (ptr = strchr(ptr, '\n')) *ptr = 0; else break;
  1535.                }
  1536.                rd->rd.res.members = rd->memberptr = calloc(hits+1, sizeof(char *));
  1537.                for (i = 0, ptr = rd->members; i < hits; ptr += strlen(ptr)+1) rd->memberptr[i++] = ptr;
  1538.             }
  1539.          }
  1540.          else rd->rd.rc = RETURN_ERROR;
  1541.          break;
  1542.       
  1543.       case RXIF_FREE:
  1544.          if (rd->members) free(rd->members);
  1545.          if (rd->memberptr) free(rd->memberptr);
  1546.          FreeVec( rd );
  1547.          break;
  1548.    }
  1549.    return;
  1550. }
  1551. ///
  1552. /* $ARB: E 53 ADDRINFO */
  1553.  
  1554. /* $ARB: B 54 ADDRRESOLVE */
  1555. /// OK
  1556. void rx_addrresolve( struct RexxHost *host, struct rxd_addrresolve **rxd, long action, struct RexxMsg *rexxmsg )
  1557. {
  1558.    struct {
  1559.       struct rxd_addrresolve rd;
  1560.       char *string;
  1561.    } *rd = (void *)*rxd;
  1562.  
  1563.    switch( action )
  1564.    {
  1565.       case RXIF_INIT:
  1566.          *rxd = AllocVec( sizeof *rd, MEMF_CLEAR );
  1567.          break;
  1568.          
  1569.       case RXIF_ACTION:
  1570.          rd->rd.res.recpt = rd->string = AllocStrBuf(80);
  1571.          if (WR_ResolveName(-1, rd->rd.arg.alias, &(rd->string), FALSE)) rd->rd.rc = RETURN_WARN;
  1572.          break;
  1573.       
  1574.       case RXIF_FREE:
  1575.          FreeStrBuf(rd->string);
  1576.          FreeVec( rd );
  1577.          break;
  1578.    }
  1579.    return;
  1580. }
  1581. ///
  1582. /* $ARB: E 54 ADDRRESOLVE */
  1583.  
  1584. /* $ARB: B 56 NEWMAILFILE */
  1585. /// OK
  1586. void rx_newmailfile( struct RexxHost *host, struct rxd_newmailfile **rxd, long action, struct RexxMsg *rexxmsg )
  1587. {
  1588.    struct {
  1589.       struct rxd_newmailfile rd;
  1590.       char result[SIZE_PATHFILE];
  1591.    } *rd = (void *)*rxd;
  1592.    struct Folder *folder;
  1593.    switch( action )
  1594.    {
  1595.       case RXIF_INIT:
  1596.          *rxd = AllocVec( sizeof *rd, MEMF_CLEAR );
  1597.          break;
  1598.          
  1599.       case RXIF_ACTION:
  1600.          if (rd->rd.arg.folder) folder = FO_GetFolderRexx(rd->rd.arg.folder, NULL);
  1601.          else folder = FO_GetCurrentFolder();
  1602.          if (folder) strcpy(rd->rd.res.filename = rd->result, MA_NewMailFile(folder, NULL, 0));
  1603.          else rd->rd.rc = RETURN_ERROR;
  1604.          break;
  1605.       
  1606.       case RXIF_FREE:
  1607.          FreeVec( rd );
  1608.          break;
  1609.    }
  1610.    return;
  1611. }
  1612. ///
  1613. /* $ARB: E 56 NEWMAILFILE */
  1614.  
  1615. /* $ARB: B 57 WRITEFROM */
  1616. /// OK
  1617. void rx_writefrom( struct RexxHost *host, struct rxd_writefrom **rxd, long action, struct RexxMsg *rexxmsg )
  1618. {
  1619.    struct rxd_writefrom *rd = *rxd;
  1620.    switch( action )
  1621.    {
  1622.       case RXIF_INIT:
  1623.          *rxd = AllocVec( sizeof *rd, MEMF_CLEAR );
  1624.          break;
  1625.          
  1626.       case RXIF_ACTION:
  1627.          if (G->WR[G->ActiveWriteWin]) setstring(G->WR[G->ActiveWriteWin]->GUI.ST_FROM, rd->arg.address);
  1628.          else rd->rc = RETURN_ERROR;
  1629.          break;
  1630.       
  1631.       case RXIF_FREE:
  1632.          FreeVec( rd );
  1633.          break;
  1634.    }
  1635.    return;
  1636. }
  1637. ///
  1638. /* $ARB: E 57 WRITEFROM */
  1639.  
  1640. /* $ARB: B 58 WRITEREPLYTO */
  1641. /// OK
  1642. void rx_writereplyto( struct RexxHost *host, struct rxd_writereplyto **rxd, long action, struct RexxMsg *rexxmsg )
  1643. {
  1644.    struct rxd_writereplyto *rd = *rxd;
  1645.    switch( action )
  1646.    {
  1647.       case RXIF_INIT:
  1648.          *rxd = AllocVec( sizeof *rd, MEMF_CLEAR );
  1649.          break;
  1650.          
  1651.       case RXIF_ACTION:
  1652.          if (G->WR[G->ActiveWriteWin]) setstring(G->WR[G->ActiveWriteWin]->GUI.ST_REPLYTO, rd->arg.address);
  1653.          else rd->rc = RETURN_ERROR;
  1654.          break;
  1655.       
  1656.       case RXIF_FREE:
  1657.          FreeVec( rd );
  1658.          break;
  1659.    }
  1660.    return;
  1661. }
  1662. ///
  1663. /* $ARB: E 58 WRITEREPLYTO */
  1664.  
  1665. /* $ARB: B 59 LISTSELECT */
  1666. /// OK
  1667. void rx_listselect( struct RexxHost *host, struct rxd_listselect **rxd, long action, struct RexxMsg *rexxmsg )
  1668. {
  1669.    struct rxd_listselect *rd = *rxd;
  1670.    APTR nl;
  1671.    switch( action )
  1672.    {
  1673.       case RXIF_INIT:
  1674.          *rxd = AllocVec( sizeof *rd, MEMF_CLEAR );
  1675.          break;
  1676.          
  1677.       case RXIF_ACTION:
  1678.          nl = G->MA->GUI.NL_MAILS;
  1679.          switch (rd->arg.mode[0])
  1680.          {
  1681.             case 'a': case 'A': DoMethod(nl, MUIM_NList_Select, MUIV_NList_Select_All, MUIV_NList_Select_On, NULL); break;
  1682.             case 'n': case 'N': DoMethod(nl, MUIM_NList_Select, MUIV_NList_Select_All, MUIV_NList_Select_Off, NULL); break;
  1683.             case 't': case 'T': DoMethod(nl, MUIM_NList_Select, MUIV_NList_Select_All, MUIV_NList_Select_Toggle, NULL); break;
  1684.             case '0': case '1': case '2': case '3': case '4': case '5': case '6': case '7':
  1685.             case '8': case '9': DoMethod(nl, MUIM_NList_Select, atol(rd->arg.mode), MUIV_NList_Select_On, NULL); break;
  1686.          }
  1687.          break;
  1688.       
  1689.       case RXIF_FREE:
  1690.          FreeVec( rd );
  1691.          break;
  1692.    }
  1693.    return;
  1694. }
  1695. ///
  1696. /* $ARB: E 59 LISTSELECT */
  1697.  
  1698. /* $ARB: B 60 READCLOSE */
  1699. /// OK
  1700. void rx_readclose( struct RexxHost *host, struct rxd_readclose **rxd, long action, struct RexxMsg *rexxmsg )
  1701. {
  1702.    struct rxd_readclose *rd = *rxd;
  1703.    switch( action )
  1704.    {
  1705.       case RXIF_INIT:
  1706.          *rxd = AllocVec( sizeof *rd, MEMF_CLEAR );
  1707.          break;
  1708.          
  1709.       case RXIF_ACTION:
  1710.          if (G->RE[G->ActiveReadWin]) DoMethod(G->App, MUIM_CallHook, &RE_CloseHook, G->ActiveReadWin);
  1711.          break;
  1712.       
  1713.       case RXIF_FREE:
  1714.          FreeVec( rd );
  1715.          break;
  1716.    }
  1717.    return;
  1718. }
  1719. ///
  1720. /* $ARB: E 60 READCLOSE */
  1721.  
  1722. /* $ARB: B 61 SETMAILFILE */
  1723. /// OK
  1724. void rx_setmailfile( struct RexxHost *host, struct rxd_setmailfile **rxd, long action, struct RexxMsg *rexxmsg )
  1725. {
  1726.    struct rxd_setmailfile *rd = *rxd;
  1727.    struct Mail *mail = NULL;
  1728.    int i;
  1729.    char *mfile;
  1730.  
  1731.    switch( action )
  1732.    {
  1733.       case RXIF_INIT:
  1734.          *rxd = AllocVec( sizeof *rd, MEMF_CLEAR );
  1735.          break;
  1736.          
  1737.       case RXIF_ACTION:
  1738.          mfile = FilePart(rd->arg.mailfile);
  1739.          for (i = 0;; i++)
  1740.          {
  1741.             DoMethod(G->MA->GUI.NL_MAILS, MUIM_NList_GetEntry, i, &mail);
  1742.             if (!mail) break;
  1743.             if (!stricmp(mail->MailFile, mfile)) { set(G->MA->GUI.NL_MAILS, MUIA_NList_Active, i); break; }
  1744.          }
  1745.          if (!mail) rd->rc = RETURN_WARN;
  1746.          break;
  1747.       
  1748.       case RXIF_FREE:
  1749.          FreeVec( rd );
  1750.          break;
  1751.    }
  1752.    return;
  1753. }
  1754. ///
  1755. /* $ARB: E 61 SETMAILFILE */
  1756.  
  1757. /* $ARB: B 62 MAILCOPY */
  1758. /// OK
  1759. void rx_mailcopy( struct RexxHost *host, struct rxd_mailcopy **rxd, long action, struct RexxMsg *rexxmsg )
  1760. {
  1761.    struct rxd_mailcopy *rd = *rxd;
  1762.    struct Folder *folder;
  1763.    switch( action )
  1764.    {
  1765.       case RXIF_INIT:
  1766.          *rxd = AllocVec( sizeof *rd, MEMF_CLEAR );
  1767.          break;
  1768.          
  1769.       case RXIF_ACTION:
  1770.          if (folder = FO_GetFolderRexx(rd->arg.folder, NULL))
  1771.             MA_MoveCopy(NULL, FO_GetCurrentFolder(), folder, TRUE);
  1772.          else rd->rc = RETURN_ERROR;
  1773.          break;
  1774.       
  1775.       case RXIF_FREE:
  1776.          FreeVec( rd );
  1777.          break;
  1778.    }
  1779.    return;
  1780. }
  1781. ///
  1782. /* $ARB: E 62 MAILCOPY */
  1783.  
  1784. /* $ARB: B 63 APPBUSY */
  1785. /// OK
  1786. void rx_appbusy( struct RexxHost *host, struct rxd_appbusy **rxd, long action, struct RexxMsg *rexxmsg )
  1787. {
  1788.    struct rxd_appbusy *rd = *rxd;
  1789.    char *s;
  1790.    switch( action )
  1791.    {
  1792.       case RXIF_INIT:
  1793.          *rxd = AllocVec( sizeof *rd, MEMF_CLEAR );
  1794.          break;
  1795.          
  1796.       case RXIF_ACTION:
  1797.          s = rd->arg.text;
  1798.          if (s) Busy(s, "", 0, 0);
  1799.          rd->rc = BusyLevel ? 1 : 0;
  1800.          break;
  1801.       
  1802.       case RXIF_FREE:
  1803.          FreeVec( rd );
  1804.          break;
  1805.    }
  1806.    return;
  1807. }
  1808. ///
  1809. /* $ARB: E 63 APPBUSY */
  1810.  
  1811. /* $ARB: B 64 APPNOBUSY */
  1812. /// OK
  1813. void rx_appnobusy( struct RexxHost *host, struct rxd_appnobusy **rxd, long action, struct RexxMsg *rexxmsg )
  1814. {
  1815.    struct rxd_appnobusy *rd = *rxd;
  1816.    switch( action )
  1817.    {
  1818.       case RXIF_INIT:
  1819.          *rxd = AllocVec( sizeof *rd, MEMF_CLEAR );
  1820.          break;
  1821.          
  1822.       case RXIF_ACTION:
  1823.          BusyEnd;
  1824.          rd->rc = BusyLevel ? 1 : 0;
  1825.          break;
  1826.       
  1827.       case RXIF_FREE:
  1828.          FreeVec( rd );
  1829.          break;
  1830.    }
  1831.    return;
  1832. }
  1833. ///
  1834. /* $ARB: E 64 APPNOBUSY */
  1835.  
  1836. /* $ARB: B 65 WRITEMAILTO */
  1837. /// OK OBSOLETE
  1838. void rx_writemailto( struct RexxHost *host, struct rxd_writemailto **rxd, long action, struct RexxMsg *rexxmsg )
  1839. {
  1840.    struct rxd_writemailto *rd = *rxd;
  1841.    switch( action )
  1842.    {
  1843.       case RXIF_INIT:
  1844.          *rxd = AllocVec( sizeof *rd, MEMF_CLEAR );
  1845.          break;
  1846.          
  1847.       case RXIF_ACTION:
  1848.          if (G->WR[G->ActiveWriteWin]) InsertAddresses(G->WR[G->ActiveWriteWin]->GUI.ST_TO, rd->arg.address, FALSE);
  1849.          else rd->rc = RETURN_ERROR;
  1850.          break;
  1851.       
  1852.       case RXIF_FREE:
  1853.          FreeVec( rd );
  1854.          break;
  1855.    }
  1856.    return;
  1857. }
  1858. ///
  1859. /* $ARB: E 65 WRITEMAILTO */
  1860.  
  1861. /* $ARB: B 66 USERINFO */
  1862. /// OK
  1863. void rx_userinfo( struct RexxHost *host, struct rxd_userinfo **rxd, long action, struct RexxMsg *rexxmsg )
  1864. {
  1865.    struct {
  1866.       struct rxd_userinfo rd;
  1867.       int folders;
  1868.    } *rd = (void *)*rxd;
  1869.    struct User *u = NULL;
  1870.    switch( action )
  1871.    {
  1872.       case RXIF_INIT:
  1873.          *rxd = AllocVec( sizeof *rd, MEMF_CLEAR );
  1874.          break;
  1875.          
  1876.       case RXIF_ACTION:
  1877.          u = US_GetCurrentUser();
  1878.          rd->rd.res.username = u->Name;
  1879.          rd->rd.res.email = C->EmailAddress;
  1880.          rd->rd.res.realname = C->RealName;
  1881.          rd->rd.res.config = G->CO_PrefsFile;
  1882.          rd->rd.res.maildir = G->MA_MailDir;
  1883.          get(G->MA->GUI.NL_FOLDERS, MUIA_NList_Entries, &rd->folders);
  1884.          rd->rd.res.folders = (long *)&rd->folders;
  1885.          break;
  1886.       
  1887.       case RXIF_FREE:
  1888.          FreeVec( rd );
  1889.          break;
  1890.    }
  1891.    return;
  1892. }
  1893. ///
  1894. /* $ARB: E 66 USERINFO */
  1895.  
  1896. /* $ARB: B 67 MAILSTATUS */
  1897. /// OK
  1898. void rx_mailstatus( struct RexxHost *host, struct rxd_mailstatus **rxd, long action, struct RexxMsg *rexxmsg )
  1899. {
  1900.    struct rxd_mailstatus *rd = *rxd;
  1901.    switch( action )
  1902.    {
  1903.       case RXIF_INIT:
  1904.          *rxd = AllocVec( sizeof *rd, MEMF_CLEAR );
  1905.          break;
  1906.          
  1907.       case RXIF_ACTION:
  1908.          switch (tolower(rd->arg.status[0]))
  1909.          {
  1910.             case 'o': MA_SetStatusTo(STATUS_OLD); break;
  1911.             case 'u': MA_SetStatusTo(STATUS_UNR); break;
  1912.             case 'h': MA_SetStatusTo(STATUS_HLD); break;
  1913.             case 'w': MA_SetStatusTo(STATUS_WFS); break;
  1914.             default: rd->rc = RETURN_WARN;
  1915.          }
  1916.          break;
  1917.       
  1918.       case RXIF_FREE:
  1919.          FreeVec( rd );
  1920.          break;
  1921.    }
  1922.    return;
  1923. }
  1924. ///
  1925. /* $ARB: E 67 MAILSTATUS */
  1926.  
  1927. /* $ARB: B 68 ISONLINE */
  1928. /// OK
  1929. void rx_isonline( struct RexxHost *host, struct rxd_isonline **rxd, long action, struct RexxMsg *rexxmsg )
  1930. {
  1931.    struct rxd_isonline *rd = *rxd;
  1932.    switch( action )
  1933.    {
  1934.       case RXIF_INIT:
  1935.          *rxd = AllocVec( sizeof *rd, MEMF_CLEAR );
  1936.          break;
  1937.          
  1938.       case RXIF_ACTION:
  1939.          rd->rc = SocketBase ? 1 : 0;
  1940.          break;
  1941.       
  1942.       case RXIF_FREE:
  1943.          FreeVec( rd );
  1944.          break;
  1945.    }
  1946.    return;
  1947. }
  1948. ///
  1949. /* $ARB: E 68 ISONLINE */
  1950.  
  1951. /* $ARB: B 70 REQUESTSTRING */
  1952. /// OK
  1953. void rx_requeststring( struct RexxHost *host, struct rxd_requeststring **rxd, long action, struct RexxMsg *rexxmsg )
  1954. {
  1955.    struct {
  1956.       struct rxd_requeststring rd;
  1957.       char string[SIZE_DEFAULT];
  1958.    } *rd = (void *)*rxd;
  1959.    char *reqtext;
  1960.  
  1961.    switch( action )
  1962.    {
  1963.       case RXIF_INIT:
  1964.          *rxd = AllocVec( sizeof *rd, MEMF_CLEAR );
  1965.          break;
  1966.          
  1967.       case RXIF_ACTION:
  1968.          reqtext = AllocReqText(rd->rd.arg.body);
  1969.          if (rd->rd.arg.string) stccpy(rd->string, rd->rd.arg.string, SIZE_DEFAULT);
  1970.          rd->rd.rc = !StringRequest(rd->string, SIZE_DEFAULT, NULL, reqtext, GetStr(MSG_Okay), NULL, GetStr(MSG_Cancel), rd->rd.arg.secret, G->MA->GUI.WI);
  1971.          rd->rd.res.string = rd->string;
  1972.          free(reqtext);
  1973.          break;
  1974.       
  1975.       case RXIF_FREE:
  1976.          FreeVec( rd );
  1977.          break;
  1978.    }
  1979.    return;
  1980. }
  1981. ///
  1982. /* $ARB: E 70 REQUESTSTRING */
  1983.  
  1984. /* $ARB: B 71 REQUESTFOLDER */
  1985. /// OK
  1986. void rx_requestfolder( struct RexxHost *host, struct rxd_requestfolder **rxd, long action, struct RexxMsg *rexxmsg )
  1987. {
  1988.    struct rxd_requestfolder *rd = *rxd;
  1989.    char *reqtext;
  1990.    struct Folder *exfolder, *folder;
  1991.  
  1992.    switch( action )
  1993.    {
  1994.       case RXIF_INIT:
  1995.          *rxd = AllocVec( sizeof *rd, MEMF_CLEAR );
  1996.          break;
  1997.          
  1998.       case RXIF_ACTION:
  1999.          reqtext = AllocReqText(rd->arg.body);
  2000.          exfolder = rd->arg.excludeactive ? FO_GetCurrentFolder() : NULL;
  2001.          if (folder = FolderRequest(NULL, reqtext, GetStr(MSG_Okay), GetStr(MSG_Cancel), exfolder, G->MA->GUI.WI)) rd->res.folder = folder->Name;
  2002.          else rd->rc = 1;
  2003.          free(reqtext);
  2004.          break;
  2005.       
  2006.       case RXIF_FREE:
  2007.          FreeVec( rd );
  2008.          break;
  2009.    }
  2010.    return;
  2011. }
  2012. ///
  2013. /* $ARB: E 71 REQUESTFOLDER */
  2014.  
  2015. /* $ARB: B 72 GETSELECTED */
  2016. /// OK
  2017. void rx_getselected( struct RexxHost *host, struct rxd_getselected **rxd, long action, struct RexxMsg *rexxmsg )
  2018. {
  2019.    struct rxd_getselected *rd = *rxd;
  2020.    struct Mail **mlist;
  2021.  
  2022.    switch( action )
  2023.    {
  2024.       case RXIF_INIT:
  2025.          *rxd = AllocVec( sizeof *rd, MEMF_CLEAR );
  2026.          break;
  2027.          
  2028.       case RXIF_ACTION:
  2029.          if (mlist = MA_CreateMarkedList(G->MA->GUI.NL_MAILS))
  2030.          {
  2031.             int i;
  2032.             rd->res.num = calloc(1+(int)mlist[0], sizeof(long));
  2033.             for (i = 0; i < (int)mlist[0]; i++) rd->res.num[i] = (long *)&(mlist[i+2]->Position);
  2034.             free(mlist);
  2035.          }
  2036.          break;
  2037.       
  2038.       case RXIF_FREE:
  2039.          if (rd->res.num) free(rd->res.num);
  2040.          FreeVec( rd );
  2041.          break;
  2042.    }
  2043.    return;
  2044. }
  2045. ///
  2046. /* $ARB: E 72 GETSELECTED */
  2047.  
  2048. /* $ARB: B 73 ADDREDIT */
  2049. /// OK
  2050. void rx_addredit( struct RexxHost *host, struct rxd_addredit **rxd, long action, struct RexxMsg *rexxmsg )
  2051. {
  2052.    struct MUI_NListtree_TreeNode *tn = NULL;
  2053.    struct rxd_addredit *rd = *rxd;
  2054.  
  2055.    switch( action )
  2056.    {
  2057.       case RXIF_INIT:
  2058.          *rxd = AllocVec( sizeof *rd, MEMF_CLEAR );
  2059.          break;
  2060.          
  2061.       case RXIF_ACTION:
  2062.          if (tn = (struct MUI_NListtree_TreeNode *)DoMethod(G->AB->GUI.LV_ADRESSES, MUIM_NListtree_GetEntry, MUIV_NListtree_GetEntry_ListNode_Active, MUIV_NListtree_GetEntry_Position_Active, 0))
  2063.          {
  2064.             struct ABEntry *ab = (struct ABEntry *)(tn->tn_User);
  2065.             if (rd->arg.alias)    stccpy(ab->Alias, rd->arg.alias, SIZE_NAME);
  2066.             if (rd->arg.name)     stccpy(ab->RealName, rd->arg.name, SIZE_REALNAME);
  2067.             if (rd->arg.email)    stccpy(ab->Address, rd->arg.email, SIZE_ADDRESS);
  2068.             if (rd->arg.pgp)      stccpy(ab->PGPId, rd->arg.pgp, SIZE_ADDRESS);
  2069.             if (rd->arg.homepage) stccpy(ab->Homepage, rd->arg.homepage, SIZE_URL);
  2070.             if (rd->arg.street)   stccpy(ab->Street, rd->arg.street, SIZE_DEFAULT);
  2071.             if (rd->arg.city)     stccpy(ab->City, rd->arg.city, SIZE_DEFAULT);
  2072.             if (rd->arg.country)  stccpy(ab->Country, rd->arg.country, SIZE_DEFAULT);
  2073.             if (rd->arg.phone)    stccpy(ab->Phone, rd->arg.phone, SIZE_DEFAULT);
  2074.             if (rd->arg.comment)  stccpy(ab->Comment, rd->arg.comment, SIZE_DEFAULT);
  2075.             if (rd->arg.birthdate) ab->BirthDay = *rd->arg.birthdate;
  2076.             if (rd->arg.image)    stccpy(ab->Photo, rd->arg.image, SIZE_PATHFILE);
  2077.             if (rd->arg.member && ab->Type == AET_LIST)
  2078.             {
  2079.                char **p, *memb = AllocStrBuf(SIZE_DEFAULT);
  2080.                if (rd->arg.add && ab->Members) memb = StrBufCpy(memb, ab->Members);
  2081.                for (p = rd->arg.member; *p; p++) { memb = StrBufCat(memb, *p); memb = StrBufCat(memb, "\n"); }
  2082.                if (ab->Members) free(ab->Members);
  2083.                ab->Members = malloc(strlen(memb)+1);
  2084.                strcpy(ab->Members, memb);
  2085.                FreeStrBuf(memb);
  2086.             }
  2087.             DoMethod(G->AB->GUI.LV_ADRESSES, MUIM_List_Redraw, MUIV_List_Redraw_All);
  2088.             G->AB->Modified = TRUE;
  2089.          }
  2090.          else rd->rc = RETURN_ERROR;
  2091.          break;
  2092.       
  2093.       case RXIF_FREE:
  2094.          FreeVec( rd );
  2095.          break;
  2096.    }
  2097.    return;
  2098. }
  2099. ///
  2100. /* $ARB: E 73 ADDREDIT */
  2101.  
  2102. /* $ARB: B 74 ADDRDELETE */
  2103. /// OK
  2104. void rx_addrdelete( struct RexxHost *host, struct rxd_addrdelete **rxd, long action, struct RexxMsg *rexxmsg )
  2105. {
  2106.    struct rxd_addrdelete *rd = *rxd;
  2107.  
  2108.    switch( action )
  2109.    {
  2110.       case RXIF_INIT:
  2111.          *rxd = AllocVec( sizeof *rd, MEMF_CLEAR );
  2112.          break;
  2113.          
  2114.       case RXIF_ACTION:
  2115.          if (!AB_GotoEntry(rd->arg.alias)) rd->rc = RETURN_WARN;
  2116.          if (!rd->rc) AB_DeleteFunc();
  2117.          break;
  2118.       
  2119.       case RXIF_FREE:
  2120.          FreeVec( rd );
  2121.          break;
  2122.    }
  2123.    return;
  2124. }
  2125. ///
  2126. /* $ARB: E 74 ADDRDELETE */
  2127.  
  2128. /* $ARB: B 76 ADDRSAVE */
  2129. /// OK
  2130. void rx_addrsave( struct RexxHost *host, struct rxd_addrsave **rxd, long action, struct RexxMsg *rexxmsg )
  2131. {
  2132.    struct rxd_addrsave *rd = *rxd;
  2133.  
  2134.    switch( action )
  2135.    {
  2136.       case RXIF_INIT:
  2137.          *rxd = AllocVec( sizeof *rd, MEMF_CLEAR );
  2138.          break;
  2139.          
  2140.       case RXIF_ACTION:
  2141.          if (rd->arg.filename)
  2142.          {
  2143.             if (!AB_SaveTree(rd->arg.filename)) rd->rc = RETURN_ERROR;
  2144.          }
  2145.          else
  2146.          {
  2147.             if (AB_SaveTree(G->AB_Filename)) G->AB->Modified = FALSE; else rd->rc = RETURN_ERROR;
  2148.          }
  2149.          break;
  2150.       
  2151.       case RXIF_FREE:
  2152.          FreeVec( rd );
  2153.          break;
  2154.    }
  2155.    return;
  2156. }
  2157. ///
  2158. /* $ARB: E 76 ADDRSAVE */
  2159.  
  2160. /* $ARB: B 77 ADDRLOAD */
  2161. /// OK
  2162. void rx_addrload( struct RexxHost *host, struct rxd_addrload **rxd, long action, struct RexxMsg *rexxmsg )
  2163. {
  2164.    struct rxd_addrload *rd = *rxd;
  2165.  
  2166.    switch( action )
  2167.    {
  2168.       case RXIF_INIT:
  2169.          *rxd = AllocVec( sizeof *rd, MEMF_CLEAR );
  2170.          break;
  2171.          
  2172.       case RXIF_ACTION:
  2173.          if (!AB_LoadTree(rd->arg.filename, FALSE, FALSE)) rd->rc = RETURN_ERROR;
  2174.          break;
  2175.       
  2176.       case RXIF_FREE:
  2177.          FreeVec( rd );
  2178.          break;
  2179.    }
  2180.    return;
  2181. }
  2182. ///
  2183. /* $ARB: E 77 ADDRLOAD */
  2184.  
  2185. /* $ARB: B 79 ADDRGOTO */
  2186. /// OK
  2187. void rx_addrgoto( struct RexxHost *host, struct rxd_addrgoto **rxd, long action, struct RexxMsg *rexxmsg )
  2188. {
  2189.    struct rxd_addrgoto *rd = *rxd;
  2190.  
  2191.    switch( action )
  2192.    {
  2193.       case RXIF_INIT:
  2194.          *rxd = AllocVec( sizeof *rd, MEMF_CLEAR );
  2195.          break;
  2196.          
  2197.       case RXIF_ACTION:
  2198.          if (!AB_GotoEntry(rd->arg.alias)) rd->rc = RETURN_WARN;
  2199.          break;
  2200.       
  2201.       case RXIF_FREE:
  2202.          FreeVec( rd );
  2203.          break;
  2204.    }
  2205.    return;
  2206. }
  2207. ///
  2208. /* $ARB: E 79 ADDRGOTO */
  2209.  
  2210. /* $ARB: B 80 ADDRNEW */
  2211. /// OK
  2212. void rx_addrnew( struct RexxHost *host, struct rxd_addrnew **rxd, long action, struct RexxMsg *rexxmsg )
  2213. {
  2214.    static struct ABEntry addr;
  2215.    struct rxd_addrnew *rd = *rxd;
  2216.  
  2217.    switch( action )
  2218.    {
  2219.       case RXIF_INIT:
  2220.          *rxd = AllocVec( sizeof *rd, MEMF_CLEAR );
  2221.          break;
  2222.          
  2223.       case RXIF_ACTION:
  2224.          clear(&addr, sizeof(struct ABEntry));
  2225.          addr.Type = AET_USER;
  2226.          if (rd->arg.type) if (tolower(*rd->arg.type) == 'g') addr.Type = AET_GROUP;
  2227.                       else if (tolower(*rd->arg.type) == 'l') addr.Type = AET_LIST;
  2228.          if (rd->arg.alias)    stccpy(addr.Alias, rd->arg.alias, SIZE_NAME);
  2229.          if (rd->arg.name)     stccpy(addr.RealName, rd->arg.name, SIZE_REALNAME);
  2230.          if (rd->arg.email)    stccpy(addr.Address, rd->arg.email, SIZE_ADDRESS);
  2231.          if (!*addr.Alias) if (addr.Type == AET_USER) EA_SetDefaultAlias(&addr); else rd->rc = RETURN_ERROR;
  2232.          if (!rd->rc)
  2233.          {
  2234.             EA_FixAlias(&addr, FALSE);
  2235.             rd->res.alias = addr.Alias;
  2236.             EA_InsertBelowActive(&addr, addr.Type == AET_GROUP ? TNF_LIST : 0);
  2237.             G->AB->Modified = TRUE;
  2238.             AppendLogVerbose(71, GetStr(MSG_LOG_NewAddress), addr.Alias, "", "", "");
  2239.          }
  2240.          break;
  2241.       
  2242.       case RXIF_FREE:
  2243.          FreeVec( rd );
  2244.          break;
  2245.    }
  2246.    return;
  2247. }
  2248. ///
  2249. /* $ARB: E 80 ADDRNEW */
  2250.  
  2251. /* $ARB: B 81 MAILCHANGESUBJECT */
  2252. /// OK
  2253. void rx_mailchangesubject( struct RexxHost *host, struct rxd_mailchangesubject **rxd, long action, struct RexxMsg *rexxmsg )
  2254. {
  2255.    struct rxd_mailchangesubject *rd = *rxd;
  2256.    struct Mail **mlist;
  2257.    switch( action )
  2258.    {
  2259.       case RXIF_INIT:
  2260.          *rxd = AllocVec( sizeof *rd, MEMF_CLEAR );
  2261.          break;
  2262.          
  2263.       case RXIF_ACTION:
  2264.          if (mlist = MA_CreateMarkedList(G->MA->GUI.NL_MAILS))
  2265.          {
  2266.             int i, selected = (int)*mlist;
  2267.             for (i = 0; i < selected; i++) MA_ChangeSubject(mlist[i+2], rd->arg.subject);
  2268.             free(mlist);
  2269.             DoMethod(G->MA->GUI.NL_MAILS, MUIM_NList_Redraw, MUIV_NList_Redraw_All);
  2270.          }
  2271.          else rd->rc = RETURN_ERROR;
  2272.          break;
  2273.       
  2274.       case RXIF_FREE:
  2275.          FreeVec( rd );
  2276.          break;
  2277.    }
  2278.    return;
  2279. }
  2280. ///
  2281. /* $ARB: E 81 MAILCHANGESUBJECT */
  2282.  
  2283. /* $ARB: B 83 GETURL */
  2284. /// OK
  2285. void rx_geturl( struct RexxHost *host, struct rxd_geturl **rxd, long action, struct RexxMsg *rexxmsg )
  2286. {
  2287.    struct rxd_geturl *rd = *rxd;
  2288.    switch( action )
  2289.    {
  2290.       case RXIF_INIT:
  2291.          *rxd = AllocVec( sizeof *rd, MEMF_CLEAR );
  2292.          break;
  2293.          
  2294.       case RXIF_ACTION:
  2295.          if (TR_OpenTCPIP())
  2296.          {
  2297.             Busy(GetStr(MSG_TR_Downloading), "", 0, 0);
  2298.             if (!TR_DownloadURL(rd->arg.url, NULL, NULL, rd->arg.filename)) rd->rc = RETURN_ERROR;
  2299.             TR_CloseTCPIP();
  2300.             BusyEnd;
  2301.          }
  2302.          else rd->rc = RETURN_WARN;
  2303.          break;
  2304.       
  2305.       case RXIF_FREE:
  2306.          FreeVec( rd );
  2307.          break;
  2308.    }
  2309.    return;
  2310. }
  2311. ///
  2312. /* $ARB: E 83 GETURL */
  2313.  
  2314.  
  2315. #ifndef RX_ALIAS_C
  2316. char *ExpandRXCommand( struct RexxHost *host, char *command )
  2317. {
  2318.    /* Insert your ALIAS-HANDLER here */
  2319.    return( NULL );
  2320. }
  2321. #endif
  2322.  
  2323.